home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 1 / QRZ Ham Radio Callsign Database - December 1993.iso / ucsd / packet / tcpip / net / netamsrc.arc / mac_misc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-02-12  |  13.9 KB  |  818 lines
  1. #include <stdio.h>
  2. #include "global.h"
  3. #include "mbuf.h"
  4. #include "internet.h"
  5. #include "iface.h"
  6. #include "mac.h"
  7. #include "cmdparse.h"
  8. #include <ctype.h>
  9.  
  10. #include "DeviceMgr.h"
  11. #include "WindowMgr.h"
  12. #include "EventMgr.h"
  13. #include "SerialDvr.h"
  14. #include "HFS.h"
  15. #include <time.h>
  16. extern long timezone;
  17. extern errno;
  18. extern struct RemoveIt Head;
  19. extern char startup[];
  20. extern char userfile[];
  21. extern char hosts[];
  22. extern char mailspool[];
  23. extern char mailqdir[];
  24. extern char mailqueue[];
  25. extern char baddir[];
  26. extern char bmrc[];
  27.  
  28. char MAC_drive[1024];
  29. char *CtoPstr();
  30. /*
  31.  * dir: Create a directory listing in a temp file and return the resulting file
  32.  * descriptor. If full == 1, give a full listing; else if full ==3, output to console,
  33.  * else return just a list
  34.  * of names.
  35.  *
  36.  */
  37. FILE *
  38. dir(path,full)
  39. char *path;
  40. int full;
  41. {
  42.     WDPBRec Mydisk;
  43.     FILE *fp, *fp1;
  44.     CInfoPBRec Everything;
  45.     OSErr e;
  46.     char working_vol[255];
  47.     char working_dir[255];
  48.     char holding_file[255];
  49.     char *PtoCstr(), *ctime();
  50.     char *ptr;
  51.     char buff[255];
  52.  
  53.  
  54.     bzero(&Mydisk, sizeof(WDPBRec));
  55.     bzero(&Everything, sizeof(Everything));
  56.  
  57.     errno = 0;
  58.     if ( full < 3)
  59.     {
  60.         if ( ( fp = fopen("dir.temp", "w")) == NULL)
  61.         {
  62.             printf("Open failed, errno = %d\n",errno);
  63.             return((FILE *)NULL);
  64.         }
  65.     }
  66.     else
  67.     {
  68.         fp = stdout;
  69.     }
  70.     
  71.     Mydisk.ioWDProcID = 0L;
  72.     Mydisk.ioWDDirID = 0L;
  73.     Mydisk.ioVRefNum = 0;
  74.     Mydisk.ioWDVRefNum = 0;
  75.     Mydisk.ioNamePtr = (StringPtr)working_vol;
  76.     if ( path[0] == '\0' )
  77.     {
  78.         path = ":";
  79.     }
  80.     MoveIt(Mydisk.ioNamePtr, path);
  81.     
  82.     e = PBOpenWD( &Mydisk, FALSE);
  83.     if ( e != noErr )
  84.     {
  85.         if ( ( fp1 = fopen(path, "r")) == NULL)
  86.         {
  87.             fclose(fp);
  88.             return((FILE *)NULL);
  89.         }
  90.         else
  91.         {
  92.             fclose(fp1);
  93.             if ( full == 0 )
  94.             {
  95.                 ptr  = rindex(path, ':');
  96.                 ptr++;
  97.                 fprintf(fp,"%s\n", ptr);
  98.                 fclose(fp);
  99.                 fp = fopen("dir.temp", "r");
  100.             }
  101.             else
  102.             {
  103.                 sprintf(holding_file, "%s", path);
  104.                 CtoPstr(holding_file);
  105.                 Everything.hFileInfo.ioNamePtr = (StringPtr)holding_file;
  106.                 Everything.hFileInfo.ioVRefNum = Mydisk.ioVRefNum;
  107.                 Everything.hFileInfo.ioFDirIndex = 0;
  108.                 Everything.hFileInfo.ioDirID = 0L;
  109.                 Everything.hFileInfo.ioCompletion = 0;
  110.                 
  111.                 if ( full == 3 )
  112.                 {
  113.                     fclose(fp);
  114.                     fp = stdout;
  115.                 }
  116.                 
  117.                 if ( (e = PBGetCatInfo( &Everything, FALSE)) != fnfErr)
  118.                 {
  119.                     ptr = ctime((long *)&Everything.hFileInfo.ioFlCrDat);
  120.                     ptr +=3;
  121.                     ptr[strlen(ptr)-9] = '\0';
  122.                     fprintf(fp,"%c  %7ld  %s  %s\n",
  123.                         (Everything.hFileInfo.ioFlAttrib & (1<<4))?'d':'-',
  124.                         Everything.hFileInfo.ioFlLgLen +
  125.                          Everything.hFileInfo.ioFlRLgLen, ptr,
  126.                         PtoCstr(Everything.hFileInfo.ioNamePtr));
  127.                 }
  128.                 else
  129.                 {
  130.                     printf("dir: found error: %d\n", e);
  131.                 }
  132.             }
  133.             if ( full < 3 )
  134.             {
  135.                 fclose(fp);
  136.                 fp = fopen("dir.temp", "r");
  137.             }
  138.             return(fp);
  139.         }
  140.     }
  141.  
  142.     Everything.hFileInfo.ioNamePtr = (StringPtr)holding_file;
  143.     Everything.hFileInfo.ioVRefNum = Mydisk.ioVRefNum;
  144.     sprintf(Everything.hFileInfo.ioNamePtr, "\p");
  145.     Everything.hFileInfo.ioFDirIndex = 1;
  146.     Everything.hFileInfo.ioDirID = Mydisk.ioWDDirID;
  147.     Everything.hFileInfo.ioCompletion = 0;
  148.  
  149.     while( (e = PBGetCatInfo( &Everything, FALSE)) != fnfErr)
  150.     {
  151.         if ( e == noErr )
  152.         {
  153.             if( full == 0)
  154.             {
  155.                 fprintf(fp, "%s\n",
  156.                      PtoCstr(Everything.hFileInfo.ioNamePtr));
  157.             }
  158.             else
  159.             {
  160.                 
  161.                 ptr = ctime((long *)&Everything.hFileInfo.ioFlCrDat);
  162.                 ptr +=3;
  163.                 ptr[strlen(ptr)-9] = '\0';
  164.                 fprintf(fp,"%c  %7ld  %s  %s\n",
  165.                     (Everything.hFileInfo.ioFlAttrib & (1<<4))?'d':'-',
  166.                     Everything.hFileInfo.ioFlLgLen +
  167.                      Everything.hFileInfo.ioFlRLgLen, ptr,
  168.                     PtoCstr(Everything.hFileInfo.ioNamePtr));
  169.             }
  170.             
  171.             Everything.hFileInfo.ioFlLgLen = 0;
  172.             Everything.hFileInfo.ioFDirIndex++;
  173.  
  174.         }
  175.         else
  176.         {
  177.             PBCloseWD(&Mydisk, FALSE);
  178.             if ( full < 3 )
  179.             {
  180.                 fclose(fp);
  181.                 fp = fopen("dir.temp", "r");
  182.                 unlink("dir.temp");
  183.                 return(fp);
  184.             }
  185.         }
  186.         Everything.hFileInfo.ioDirID = Mydisk.ioWDDirID;
  187.     }
  188.     PBCloseWD(&Mydisk, FALSE);
  189.     if ( full < 3)
  190.     {
  191.         fclose(fp);
  192.         fp = fopen("dir.temp", "r");
  193.         unlink("dir.temp");
  194.     }
  195.     return(fp);
  196. }
  197.  
  198. /*
  199.  * MoveIt: this is like a bcopy, but uses pascal string type
  200.  * of data.
  201.  */
  202.  
  203. MoveIt(to,from)
  204. char *to, *from;
  205. {
  206.     int size;
  207.  
  208.     bzero(to, 3);
  209.     to[0] = size = strlen(from);
  210.     if ( size <= 0)
  211.     {
  212.         printf("MoveIt: size <= 0 (%d\n", size);
  213.         return;
  214.     }
  215.     to++;
  216.     while( size-- )
  217.         *to++ = *from++;    
  218. }
  219.  
  220. /*
  221.  * mktemp: make temporary file and return a pointer to it.
  222.  */
  223.  
  224. char *mktemp(ff)
  225. char *ff;
  226. {
  227.     long tt;
  228.     char *ptr;
  229.     if ( ( ptr = index(ff, 'X') ) == NULL)
  230.     {
  231.         ptr = ff;
  232.     }
  233.     tt = TickCount();
  234.     tt &= 0xffffffff;
  235.     sprintf(ptr, "%ld", tt);
  236.     return(ff);
  237. }
  238.  
  239. /*
  240.  * index: find the first char in string that matches arg.  LSC does not
  241.  * have this routine.
  242.  */
  243.  
  244. char *index(str, find)
  245. char *str;
  246. char find;
  247. {
  248.     char *strchr();
  249.  
  250.     return(strchr(str, find));
  251. }
  252.  
  253.  
  254. static WDPBRec Mydisk;
  255. static CInfoPBRec Everything;
  256. static IsOpen = 0;    /* tells me that the file is open */
  257. static char *name_ptr;
  258. static char working_dir[255];
  259. static char holding_file[255];
  260. static     char working_vol[255];
  261.  
  262. /*
  263.  * filedir: find a file that matches the dest arg
  264.  */
  265.  
  266. char *filedir(path,value,dest)
  267. char *path;
  268. int   value;
  269. char *dest;
  270. {
  271.  
  272.     FILE *fp;
  273.     OSErr e;
  274.     char *PtoCstr(), *ctime();
  275.     char *ptr;
  276.     char buff[255];
  277.     char *rindex();
  278.     char keep;
  279.     
  280.     dest[0] = '\0';
  281.     if ( IsOpen == 0 && value == 0)
  282.     {
  283.         Mydisk.ioWDProcID = 0L;
  284.         Mydisk.ioWDDirID = 0L;
  285.         Mydisk.ioVRefNum = 0;
  286.         Mydisk.ioWDVRefNum = 0;
  287.         Mydisk.ioNamePtr = (StringPtr)working_vol;
  288.         if ( path[0] == '\0' )
  289.         {
  290.             path = ":";
  291.         }
  292.         if ( (ptr = rindex(path, ':')) != NULL)
  293.         {
  294.             keep = *ptr;
  295.             *ptr = '\0';
  296.             MoveIt(Mydisk.ioNamePtr, path);
  297.             *ptr = keep;
  298.         }
  299.         else
  300.         {
  301.             MoveIt(Mydisk.ioNamePtr, path);
  302.         }
  303.         if ( ( name_ptr = rindex( path, '.')) != NULL)
  304.         {
  305.             name_ptr++;
  306.         }
  307.         else
  308.         {
  309.             name_ptr = "";
  310.         }
  311.     }
  312.     
  313.     e = PBOpenWD( &Mydisk, FALSE);
  314.     
  315.     if ( e != noErr )
  316.     {
  317.         printf("filedir: ERROR in PWOpenWD\n");
  318.         IsOpen = 0;
  319.         return( (char *)-1);
  320.     }
  321.         
  322.         /* mark as open */
  323.         
  324.     IsOpen = 1;
  325.  
  326.     /*
  327.      * set up for getting the info from the directory
  328.      */
  329.      
  330.     Everything.hFileInfo.ioNamePtr = (StringPtr)holding_file;
  331.     Everything.hFileInfo.ioVRefNum = Mydisk.ioVRefNum;
  332.     sprintf(Everything.hFileInfo.ioNamePtr, "\p");
  333.     
  334.     if ( value == 0 )
  335.     {
  336.         Everything.hFileInfo.ioFDirIndex = 1;
  337.     }
  338.     
  339.     Everything.hFileInfo.ioDirID = Mydisk.ioWDDirID;
  340.     Everything.hFileInfo.ioCompletion = 0;
  341.  
  342.     
  343.     while( (e = PBGetCatInfo( &Everything, FALSE)) != fnfErr)
  344.     {
  345.         if ( e == noErr )
  346.         {
  347.             
  348.             PtoCstr(Everything.hFileInfo.ioNamePtr);
  349.             if ( ( ptr = index( Everything.hFileInfo.ioNamePtr, '.')) != NULL) 
  350.             {
  351.                 ptr++;
  352.                 if ( strncmp(ptr, name_ptr, strlen(name_ptr)) == 0) 
  353.                 {
  354.                     sprintf(dest,"%s", Everything.hFileInfo.ioNamePtr);
  355.                     Everything.hFileInfo.ioFDirIndex++;
  356.                     PBCloseWD(&Mydisk, FALSE);
  357.                     return;
  358.                 }
  359.             }
  360.             Everything.hFileInfo.ioFlLgLen = 0;
  361.             Everything.hFileInfo.ioFDirIndex++;
  362.             Everything.hFileInfo.ioDirID = Mydisk.ioWDDirID;
  363.  
  364.         }
  365.         else
  366.         {
  367.             IsOpen = 0;
  368.             PBCloseWD(&Mydisk, FALSE);
  369.             return(0);
  370.         }
  371.         Everything.hFileInfo.ioDirID = Mydisk.ioWDDirID;
  372.     }
  373.     IsOpen = 0;
  374.     PBCloseWD(&Mydisk, FALSE);
  375. }
  376.  
  377. /*
  378.  * rindex: find the last char in string which matches arg.  LSC does not
  379.  * have this routine.
  380.  */
  381.  
  382. char *rindex(str, c)
  383. char *str, c;
  384. {
  385.     char *strrchr();
  386.     return(strrchr(str, c));
  387. }
  388.  
  389. int asy_attach();
  390. extern struct cmds attab[];
  391.  
  392. /*
  393.  * eihalt: normally this would wait for an interrupt, but it doesn't here.
  394.  * this will check for the button.  If the button has been depressed, the process
  395.  * exits
  396.  */
  397.  
  398. eihalt()
  399. {
  400.     if (Button())
  401.     {
  402.         iostop();
  403.         exit(0);
  404.     }
  405.     return(0);
  406. }
  407.  
  408. /*
  409.  * kbread: see if a char is available on keyboard, if so go get it.
  410.  */
  411. kbread()
  412. {
  413.     int    mask;
  414.     int    ok;
  415.     char    c = -1;
  416.     if( kbhit() ){
  417.         c = getch();
  418.     }
  419.     return(c);
  420. }
  421.  
  422. /*
  423.  * clksec: return the amount of time in secs.
  424.  */
  425.  
  426. int32
  427. clksec()
  428. {
  429.     return(time(NULL));
  430. }
  431.  
  432. /*
  433.  * tmpfile: create a temporary file.  Remember it so we can delete it later because
  434.  * the mac does not allow the file to be deleted when it is open.
  435.  */
  436.  
  437. FILE *
  438. tmpfile()
  439. {
  440.     FILE *tmp;
  441.     char *mktemp();
  442.     char *ptr;
  443.     char *name;
  444.     struct RemoveIt *rptr;
  445.     
  446.     if ( ( ptr = malloc(strlen("SMTPXXXXXX")+1)) == NULLCHAR)
  447.     {
  448.         printf("Could not open SMTPXXXXXX for temp file.\n");
  449.         return(NULL);
  450.     }
  451.     sprintf(ptr, "SMTPXXXXXX");
  452.     name = mktemp(ptr);
  453.     if ( ( tmp = fopen(name, "w+") ) == NULL)
  454.     {
  455.         printf("tmpfile: counld not create temp file. (%s)\n", name);
  456.         return(NULL);
  457.     }
  458.     rptr = &Head;
  459.     while(rptr->next != NULL )
  460.     {
  461.         rptr = rptr->next;
  462.     }
  463.     
  464.     if ( (rptr->next = (struct RemoveIt *)malloc(sizeof (struct RemoveIt)) ) == NULL)
  465.     {
  466.         printf("Could not allocate memory for structure RemoveIt\n");
  467.         return(tmp);
  468.     }
  469.     if ( (rptr->name_ptr = malloc(strlen(name)+1) ) == NULL)
  470.     {
  471.         printf("Could not allocate memory for %s\n", name);
  472.         return(tmp);
  473.     }
  474.     
  475.     sprintf(rptr->name_ptr, "%s", name);
  476.     rptr = rptr->next;
  477.     rptr->next = NULL;
  478.     (void)free(ptr);
  479.     return ( tmp );
  480. }
  481.  
  482. /* restore: stub */
  483. restore()
  484. {}
  485.  
  486. /* stxrdy: stub */
  487. stxrdy()
  488. {return(1);}
  489.  
  490. /* disable: stub */
  491. disable()
  492. {}
  493.  
  494. /* memstat: stub */
  495. memstat()
  496. {
  497.     return(0);
  498. }
  499.  
  500. /* checks the time then ticks and updates ISS */
  501. static int32 clkval = 0;
  502. void
  503. check_time()
  504. {
  505.     int32 iss();
  506.     int32 clksec();
  507.  
  508.     if(clkval != clksec()){
  509.         clkval = clksec();
  510.         tick();
  511.         (void)iss();
  512.     }
  513. }
  514.  
  515. /*
  516.  * Access: check the file for access permission.  Some of this has to be faked on
  517.  * a Mac, since it does not have access bits.
  518.  */
  519.  
  520. access(str, perm)
  521.  char *str;
  522.  int perm;
  523. {
  524.     FILE *fptr;
  525.     CInfoPBRec    paramBlock;
  526.     OSErr e;
  527.     char *CtoPstr();
  528.  
  529.     paramBlock.hFileInfo.ioCompletion = 0;
  530.     paramBlock.hFileInfo.ioVRefNum = 0;
  531.     paramBlock.hFileInfo.ioFDirIndex = 0;
  532.     paramBlock.hFileInfo.ioDirID = 0;
  533.     paramBlock.hFileInfo.ioNamePtr = CtoPstr(str);
  534.  
  535.     /*
  536.      * Get info on file named in ioNamePtr
  537.      */
  538.      
  539.     e = PBGetCatInfo( ¶mBlock, FALSE);
  540.     PtoCstr(str);
  541.     
  542.     /*
  543.      * if there is an error then find out if the file is present.  If so
  544.      * see if user wants to create the file
  545.      */
  546.      
  547.     if ( e != noErr )
  548.     {
  549.         if ( ( e == fnfErr) && (perm == 2))
  550.         {
  551.             return(0);
  552.         }
  553.         else
  554.         {
  555.             return(1);
  556.         }
  557.     }
  558.     /*
  559.      * check to see if the file is locked or open.  refuse it if it is.
  560.      */
  561.      
  562.     if ( (BitTst( ¶mBlock.hFileInfo.ioFlAttrib, 0) 
  563.             || BitTst( ¶mBlock.hFileInfo.ioFlAttrib, 7) )
  564.             && perm == 4 )
  565.     {
  566.         return(1);
  567.     }
  568.     else
  569.         return(0);
  570.     
  571. }
  572.  
  573. /*
  574.  * Bzero: zero out a buffer
  575.  */
  576.  
  577. bzero(str, cnt)
  578. char *str;
  579. int    cnt;
  580. {
  581.     while(cnt-- != 0)
  582.         *str++ = '\0';
  583. }
  584.  
  585. /*
  586.  * memcmp: compare memory
  587.  */
  588.  
  589. memcmp(str1, str2, len)
  590. char *str1, *str2;
  591. int len;
  592. {
  593.     return( strncmp(str1, str2, len));
  594. }
  595.  
  596. /* 
  597.  * memset: set a value in memory
  598.  */
  599.  
  600. memset(str, value, len)
  601. char *str;
  602. int value, len;
  603. {
  604.     while ( len-- != 0)
  605.     {
  606.         *str++ = value;
  607.     }
  608. }
  609.  
  610. /*
  611.  * memcpy: copy from one place to another
  612.  */
  613.  
  614. memcpy(str1, str2, len)
  615. char *str1, *str2;
  616. int len;
  617. {
  618.     while ( len-- != 0)
  619.         *str1++ = *str2++;
  620. }
  621.  
  622. /* List directory to console */
  623. dodir(argc,argv)
  624. int argc;
  625. char *argv[];
  626. {
  627.     if ( argc > 2)
  628.         dir( argv[1], 3);
  629.     else
  630.         dir(":",3);
  631.     return 0;
  632. }
  633.  
  634. /*
  635.  * docd: perform a change directory
  636.  */
  637.  
  638. docd(argc, argv)
  639. int argc;
  640. char *argv[];
  641. {
  642.     char dirname[128],*getwd();
  643.  
  644.     if(argc > 1){
  645.         if(chdir(argv[1]) == -1){
  646.             printf("Can't change directory\n");
  647.             return 1;
  648.         }
  649.     }
  650.     if(getwd(dirname,0) != NULLCHAR){
  651.         printf("%s\n",dirname);
  652.     }
  653.     return 0;
  654. }
  655.  
  656. chdir( path )
  657. char * path;
  658. {
  659.     WDPBRec    Mydisk;
  660.     int err;
  661.     register char * cp;
  662.     char *index();
  663.     OSErr e;
  664.  
  665. #ifdef DEBUG
  666.     printf("Entering chdir\n");
  667. #endif
  668.  
  669.     Mydisk.ioWDProcID = 0L;
  670.     Mydisk.ioWDDirID = 0L;
  671.      Mydisk.ioVRefNum = 0;
  672.     printf("chdir: path = %s\n", path);
  673.     Mydisk.ioWDVRefNum = 0;
  674.     CtoPstr(path);
  675.     Mydisk.ioNamePtr = path;
  676. #ifdef DEBUG
  677.     printf("chdir: calling PBOpenWD.\n");
  678.     printf("Mydisk.ioVRefNum = %d\n", Mydisk.ioVRefNum);
  679. #endif    
  680.     e = PBOpenWD( &Mydisk, FALSE);
  681.     
  682.     if ( e != noErr )
  683.     {
  684.         PtoCstr(path);
  685.         return(-1);
  686.     }
  687.     
  688.     if ( ( e = PBHSetVol( &Mydisk, FALSE) ) != noErr)
  689.     {
  690.         PtoCstr(path);
  691.         return(-1);
  692.     }
  693.  
  694.     PtoCstr(path);
  695.     return 0;
  696.  
  697. }
  698.  
  699. char *getwd()
  700. {
  701.     return(NULL);
  702. }
  703.  
  704. /*
  705.  * doshell:  execute a shell for the user
  706.  */
  707.  
  708. doshell()
  709. {
  710.     printf("SHELL is not implemented.\n");
  711. }
  712.  
  713. char *timez = "CST";
  714.  
  715. char *getenv(str)
  716. char *str;
  717. {
  718.     return(timez);
  719. }
  720.  
  721. mkdir(name, mode)
  722. char *name;
  723. int mode;
  724. {
  725.  
  726.     HParamBlockRec paramBlock;
  727.     int e;
  728.     
  729.     paramBlock.fileParam.ioCompletion = 0;
  730.     paramBlock.fileParam.ioNamePtr = CtoPstr(name);
  731.     paramBlock.fileParam.ioDirID = 0L;
  732.     paramBlock.fileParam.ioVRefNum = 0;
  733.  
  734.     if ( ( e = PBDirCreate(¶mBlock, FALSE)) != 0 )
  735.     {
  736.         printf("Could not create directory. error = %d\n", e);
  737.         return(-1);
  738.     }
  739.  
  740.     return(0);
  741. }
  742.  
  743. rmdir(name)
  744. char *name;
  745. {
  746.     HParamBlockRec paramBlock;
  747.     int e;
  748.     
  749.     paramBlock.fileParam.ioCompletion = 0;
  750.     paramBlock.fileParam.ioNamePtr = CtoPstr(name);
  751.     paramBlock.fileParam.ioFVersNum = 0;
  752.     paramBlock.fileParam.ioVRefNum = 0;
  753.     
  754.     if ( ( e = PBDelete(¶mBlock, FALSE)) != 0 )
  755.     {
  756.         printf("Could not create directory, error = %d\n", e);
  757.         return(-1);
  758.     }
  759.     return(0);
  760. }
  761.  
  762.  
  763. mac_files()
  764. {
  765.     int iovRef, e;
  766.     char *PtoCstr();
  767.     int len;
  768.     /*
  769.      * Now find the Volume name and put it back.
  770.      */
  771.     setmem(MAC_drive,0, sizeof(MAC_drive));
  772.     
  773.     if ( ( e = GetVol(MAC_drive, &iovRef) ) != 0)
  774.     {
  775.         printf("mac_files: could not get the volume name.\n");
  776.         exit(-1);    
  777.     }
  778.     else
  779.     {
  780.         (void) PtoCstr(MAC_drive);
  781.     }
  782.  
  783.     check_len(STARTUP);
  784.     sprintf(startup,"%s%s\0", MAC_drive, STARTUP);
  785.     check_len(USERFILE);
  786.     sprintf(userfile,"%s%s", MAC_drive, USERFILE);
  787.     check_len(HOSTS);
  788.     sprintf(hosts,"%s%s", MAC_drive, HOSTS);
  789.     check_len(MAILSPOOL);
  790.     sprintf(mailspool,"%s%s", MAC_drive, MAILSPOOL);
  791.     check_len(MAILQDIR);
  792.     sprintf(mailqdir,"%s%s", MAC_drive, MAILQDIR);
  793.     check_len(MAILQUEUE);
  794.     sprintf(mailqueue,"%s%s", MAC_drive, MAILQUEUE);
  795.     check_len(BADDIR);
  796.     sprintf(baddir,"%s%s", MAC_drive, BADDIR);
  797.     check_len(BMRC);
  798.     sprintf(bmrc,"%s%s", MAC_drive, BMRC);
  799.     check_len(ROUTEQDIR);
  800.     sprintf(bmrc,"%s%s", MAC_drive, BMRC);
  801. }
  802.  
  803. check_len(str)
  804. char *str;
  805. {
  806.     int len;
  807.  
  808.     len = strlen("This line will be overwritten by the mac stuff.  MAX LINE");
  809.     if ( (strlen(MAC_drive) + strlen(str)) > len )
  810.     {
  811.         printf("Pathname to %s (max is %d) is to long, please shorten the path.\n", str, len);
  812.         printf("The pathname you attempted was %s%s\n", MAC_drive, str);
  813.         exit(1);
  814.     }
  815. }
  816.  
  817. chktasker()
  818. {}